/* Copyright (C) 2012 Kristian Lauszus, TKJ Electronics. All rights reserved.
   Copyright (C) 2015 guruthree

 This software may be distributed and modified under the terms of the GNU
 General Public License version 2 (GPL2) as published by the Free Software
 Foundation and appearing in the file GPL2.TXT included in the packaging of
 this file. Please note that GPL2 Section 2[b] requires that all works based
 on this software must also be made publicly available under the terms of
 the GPL2 ("Copyleft").

 Contact information
 -------------------

 Kristian Lauszus, TKJ Electronics
 Web      :  http://www.tkjelectronics.com
 e-mail   :  kristianl@tkjelectronics.com

 guruthree
 Web      :  https://github.com/guruthree/
 */


#ifndef _xboxone_h_
#define _xboxone_h_

#include "Usb.h"
#include "xboxEnums.h"

/* Xbox One data taken from descriptors */
#define XBOX_ONE_EP_MAXPKTSIZE                  64 // Max size for data via USB

/* Names we give to the 3 XboxONE pipes */
#define XBOX_ONE_CONTROL_PIPE                   0
#define XBOX_ONE_OUTPUT_PIPE                    1
#define XBOX_ONE_INPUT_PIPE                     2

#define XBOX_ONE_MAX_ENDPOINTS                  3

// PID and VID of the different versions of the controller - see: https://github.com/torvalds/linux/blob/master/drivers/input/joystick/xpad.c

// Official controllers
#define XBOX_VID1                               0x045E // Microsoft Corporation
#define XBOX_ONE_PID1                           0x02D1 // Microsoft X-Box One pad
#define XBOX_ONE_PID2                           0x02DD // Microsoft X-Box One pad (Firmware 2015)
#define XBOX_ONE_PID3                           0x02E3 // Microsoft X-Box One Elite pad
#define XBOX_ONE_PID4                           0x02EA // Microsoft X-Box One S pad

// Unofficial controllers
#define XBOX_VID2                               0x0738 // Mad Catz
#define XBOX_VID3                               0x0E6F // Afterglow
#define XBOX_VID4                               0x0F0D // HORIPAD ONE
#define XBOX_VID5                               0x1532 // Razer
#define XBOX_VID6                               0x24C6 // PowerA

#define XBOX_ONE_PID5                           0x4A01 // Mad Catz FightStick TE 2 - might have different mapping for triggers?
#define XBOX_ONE_PID6                           0x0139 // Afterglow Prismatic Wired Controller
#define XBOX_ONE_PID7                           0x0146 // Rock Candy Wired Controller for Xbox One
#define XBOX_ONE_PID8                           0x0067 // HORIPAD ONE
#define XBOX_ONE_PID9                           0x0A03 // Razer Wildcat
#define XBOX_ONE_PID10                          0x541A // PowerA Xbox One Mini Wired Controller
#define XBOX_ONE_PID11                          0x542A // Xbox ONE spectra
#define XBOX_ONE_PID12                          0x543A // PowerA Xbox One wired controller

/** This class implements support for a Xbox ONE controller connected via USB. */
class XBOXONE : public USBDeviceConfig, public UsbConfigXtracter {
public:
        /**
         * Constructor for the XBOXONE class.
         * @param  pUsb   Pointer to USB class instance.
         */
        XBOXONE(USB *pUsb);

        /** @name USBDeviceConfig implementation */
        /**
         * Initialize the Xbox Controller.
         * @param  parent   Hub number.
         * @param  port     Port number on the hub.
         * @param  lowspeed Speed of the device.
         * @return          0 on success.
         */
        virtual uint8_t Init(uint8_t parent, uint8_t port, bool lowspeed);
        /**
         * Release the USB device.
         * @return 0 on success.
         */
        virtual uint8_t Release();
        /**
         * Poll the USB Input endpoins and run the state machines.
         * @return 0 on success.
         */
        virtual uint8_t Poll();

        /**
         * Get the device address.
         * @return The device address.
         */
        virtual uint8_t GetAddress() {
                return bAddress;
        };

        /**
         * Used to check if the controller has been initialized.
         * @return True if it's ready.
         */
        virtual bool isReady() {
                return bPollEnable;
        };

        /**
         * Read the poll interval taken from the endpoint descriptors.
         * @return The poll interval in ms.
         */
        uint8_t readPollInterval() {
                return pollInterval;
        };

        /**
         * Used by the USB core to check what this driver support.
         * @param  vid The device's VID.
         * @param  pid The device's PID.
         * @return     Returns true if the device's VID and PID matches this driver.
         */
        virtual bool VIDPIDOK(uint16_t vid, uint16_t pid) {
                return ((vid == XBOX_VID1 || vid == XBOX_VID2 || vid == XBOX_VID3 || vid == XBOX_VID4 || vid == XBOX_VID5 || vid == XBOX_VID6) &&
                    (pid == XBOX_ONE_PID1 || pid == XBOX_ONE_PID2 || pid == XBOX_ONE_PID3 || pid == XBOX_ONE_PID4 ||
                        pid == XBOX_ONE_PID5 || pid == XBOX_ONE_PID6 || pid == XBOX_ONE_PID7 || pid == XBOX_ONE_PID8 ||
                        pid == XBOX_ONE_PID9 || pid == XBOX_ONE_PID10 || pid == XBOX_ONE_PID11 || pid == XBOX_ONE_PID12));
        };
        /**@}*/

        /** @name Xbox Controller functions */
        /**
         * getButtonPress(ButtonEnum b) will return true as long as the button is held down.
         *
         * While getButtonClick(ButtonEnum b) will only return it once.
         *
         * So you instance if you need to increase a variable once you would use getButtonClick(ButtonEnum b),
         * but if you need to drive a robot forward you would use getButtonPress(ButtonEnum b).
         * @param  b          ::ButtonEnum to read.
         * @return            getButtonClick(ButtonEnum b) will return a bool, while getButtonPress(ButtonEnum b) will return a word if reading ::L2 or ::R2.
         */
        uint16_t getButtonPress(ButtonEnum b);
        bool getButtonClick(ButtonEnum b);

        /**
         * Return the analog value from the joysticks on the controller.
         * @param  a          Either ::LeftHatX, ::LeftHatY, ::RightHatX or ::RightHatY.
         * @return            Returns a signed 16-bit integer.
         */
        int16_t getAnalogHat(AnalogHatEnum a);

        /**
         * Used to call your own function when the controller is successfully initialized.
         * @param funcOnInit Function to call.
         */
        void attachOnInit(void (*funcOnInit)(void)) {
                pFuncOnInit = funcOnInit;
        };
        /**@}*/

        /** True if a Xbox ONE controller is connected. */
        bool XboxOneConnected;

protected:
        /** Pointer to USB class instance. */
        USB *pUsb;
        /** Device address. */
        uint8_t bAddress;
        /** Endpoint info structure. */
        EpInfo epInfo[XBOX_ONE_MAX_ENDPOINTS];

        /** Configuration number. */
        uint8_t bConfNum;
        /** Total number of endpoints in the configuration. */
        uint8_t bNumEP;
        /** Next poll time based on poll interval taken from the USB descriptor. */
        uint32_t qNextPollTime;

        /** @name UsbConfigXtracter implementation */
        /**
         * UsbConfigXtracter implementation, used to extract endpoint information.
         * @param conf  Configuration value.
         * @param iface Interface number.
         * @param alt   Alternate setting.
         * @param proto Interface Protocol.
         * @param ep    Endpoint Descriptor.
         */
        void EndpointXtract(uint8_t conf, uint8_t iface, uint8_t alt, uint8_t proto, const USB_ENDPOINT_DESCRIPTOR *ep);
        /**@}*/

        /**
         * Used to print the USB Endpoint Descriptor.
         * @param ep_ptr Pointer to USB Endpoint Descriptor.
         */
        void PrintEndpointDescriptor(const USB_ENDPOINT_DESCRIPTOR* ep_ptr);

private:
        /**
         * Called when the controller is successfully initialized.
         * Use attachOnInit(void (*funcOnInit)(void)) to call your own function.
         */
        void onInit();
        void (*pFuncOnInit)(void); // Pointer to function called in onInit()

        uint8_t pollInterval;
        bool bPollEnable;

        /* Variables to store the buttons */
        uint16_t ButtonState;
        uint16_t OldButtonState;
        uint16_t ButtonClickState;
        int16_t hatValue[4];
        uint16_t triggerValue[2];
        uint16_t triggerValueOld[2];

        bool L2Clicked; // These buttons are analog, so we use we use these bools to check if they where clicked or not
        bool R2Clicked;

        uint8_t readBuf[XBOX_ONE_EP_MAXPKTSIZE]; // General purpose buffer for input data

        void readReport(); // Used to read the incoming data

        /* Private commands */
        uint8_t XboxCommand(uint8_t* data, uint16_t nbytes);
};
#endif
